//package com.standardoperationapp.bluetooth;
//
//import android.bluetooth.BluetoothAdapter;
//import android.bluetooth.BluetoothDevice;
//import android.bluetooth.BluetoothGatt;
//import android.bluetooth.BluetoothGattCallback;
//import android.bluetooth.BluetoothGattCharacteristic;
//import android.bluetooth.BluetoothGattDescriptor;
//import android.bluetooth.BluetoothGattService;
//import android.bluetooth.BluetoothManager;
//import android.bluetooth.BluetoothProfile;
//import android.bluetooth.le.ScanCallback;
//import android.bluetooth.le.ScanResult;
//import android.content.Context;
//import android.content.Intent;
//import android.os.Build;
//import android.os.Handler;
//import android.os.Message;
//import android.text.TextUtils;
//
//import androidx.annotation.RequiresApi;
//import androidx.bluetooth.ScanFilter;
//
//import java.util.List;
//import java.util.UUID;
//
//public class OpenNokeBleLockHelper {
//    public final static String ACTION_GATT_CONNECTED = "com.nokelock..ACTION_GATT_CONNECTED";// 连接
//    public final static String ACTION_GATT_DISCONNECTED = "com.nokelock..ACTION_GATT_DISCONNECTED";// 断开
//    public final static String ACTION_GATT_SERVICES_DISCOVERED = "com.nokelock..ACTION_GATT_SERVICES_DISCOVERED";// 发现服务
//    public static final String ACTION_SCAN_DEVICE = "com.nokelock.ACTION_SCAN_DEVICE";//扫描设备
//    public static final String ACTION_BLE_REAL_DATA = "com.nokelock..ACTION_BLE_REAL_DATA";//通知数据
//
//    private BluetoothManager mBluetoothManager;
//    private BluetoothAdapter mBluetoothAdapter;
//    //private String  _mCurrentOpeningdevicename;
//    public BluetoothGatt mBluetoothGatt;
//    private BluetoothGattCharacteristic write_characteristic;
//
//    //初始化蓝牙
//    private boolean initBlueTooth(){
//        //mkey = com.tideen.core.ConfigHelper.getNodeBleLockKey();
//        mBluetoothManager = (BluetoothManager) mactivity.getSystemService(Context.BLUETOOTH_SERVICE);
//        mBluetoothAdapter = mBluetoothManager.getAdapter();
//        if (null == mBluetoothAdapter)
//            return false;
////        if (!mBluetoothAdapter.isEnabled()) {
////            mBluetoothAdapter.enable();
////        }
//        if (mBluetoothAdapter!=null&&!mBluetoothAdapter.isEnabled()){
//            Intent enableBT = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
//            mactivity.startActivityForResult(enableBT, 1);
//            return false;
//        }
//        return true;
//    }
//    //启动扫描
//    public void start() {
//        try {
//            if (isStarted)
//                return;
//            if (!initBlueTooth())
//                return;
//            isStarted = true;
//           // mBluetoothAdapter.startLeScan(new UUID[]{RX_SERVICE_UUID,RX_CHAR_UUID,TX_CHAR_UUID},leScanCallback);
//           // mBluetoothAdapter.startLeScan(leScanCallback);
//            ScanFilter.Builder scanfilterbuilder = new ScanFilter.Builder();
//            //scanfilterbuilder.setServiceUuid(ParcelUuid.fromString("6e400001-b5a3-f393-e0a9-e50e24dcca9e"));
//            ScanFilter filter = scanfilterbuilder.build();
//            ScanSettings.Builder scanSettingsbuilder=new ScanSettings.Builder();
//            scanSettingsbuilder.setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY);
//            ScanSettings scanSettings= scanSettingsbuilder.build();
//           mBluetoothAdapter.getBluetoothLeScanner().startScan(Collections.singletonList(filter), scanSettings, myScanCallback);
//            //startMonitorBluetoothDiscover();
//           Log.e(TAG,"OpenNokeBleLockHelper.start.hashCode="+this.hashCode());
//        }catch (Exception ee){
//            LogHelper.writeException(ee);
//        }
//    }
//
//    public void stop(){
//        try {
//            stopCaptureTimeCount();
//            if (mBluetoothAdapter != null) {
//               // mBluetoothAdapter.stopLeScan(leScanCallback);
//                if (mBluetoothGatt != null) {
//                    mBluetoothGatt.disconnect();
//                    mBluetoothGatt.close();
//                }
//                mBluetoothAdapter.getBluetoothLeScanner().stopScan(myScanCallback);
//                isStarted = false;
//            }
//           // stopMonitorBluetoothDiscover();
//           Log.e(TAG,"OpenNokeBleLockHelper.stop.hashCode="+this.hashCode());
//        }catch (Exception ee){
//            LogHelper.writeException(ee);
//        }
//    }
//    //断开与当前蓝牙的连接，试手机能够继续扫描其它蓝牙设备
//    public void disconnect(){
//        if (mBluetoothGatt != null) {
//            mBluetoothGatt.disconnect();
//            mBluetoothGatt.close();
//            mLockIsOpened=false;
//        }
//    }
//
//    private Object mSyncOpenLockObj=new Object();
//    private BluetoothAdapter.LeScanCallback leScanCallback = new BluetoothAdapter.LeScanCallback() {
//        @Override
//        public void onLeScan(BluetoothDevice device, int rssi, byte[] scanRecord) {
//            myonLeScan(device,rssi,scanRecord);
//        }
//    };
//    //搜索蓝牙
//    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
//    ScanCallback myScanCallback=new ScanCallback() {
//        @Override
//        @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
//        public void onScanResult(int callbackType, ScanResult result) {
//            super.onScanResult(callbackType, result);
//            //LogHelper.write("BLEScanCallback.onScanResult callbackType="+callbackType);
//            myonLeScan(result.getDevice(),result.getRssi(),result.getScanRecord().getBytes());
//        }
//
//        @Override
//        public void onBatchScanResults(List<ScanResult> results) {
//            super.onBatchScanResults(results);
//        }
//
//        @Override
//        public void onScanFailed(int errorCode) {
//            super.onScanFailed(errorCode);
//           Log.e(TAG,"BLEScanCallback.onScanFailed errorCode="+errorCode);
//        }
//    };
//    private synchronized void myonLeScan(BluetoothDevice bluetoothdevice, int rssi, byte[] scanRecord) {
//        try {
//            //LogHelper.write("Bluetooth Find:" + device.getName());
//            //Log.e("TLock","Bluetooth Find:" + device.getName());
//            String devicename=bluetoothdevice.getName();
//            if(TextUtils.isEmpty(devicename))
//                return;
//           //Log.e(TAG,"Find Ble Device:" + devicename + "," + device.getAddress());
//            if(!devicename.startsWith("TDL")&&!devicename.startsWith("OK")&&!devicename.startsWith("SGL")&&!devicename.startsWith("TMPL")
//                    &&!devicename.startsWith("TMOL")) {
//                return;
//            }
//
//            synchronized(mSyncOpenLockObj) {
//                    if (!mbluetoothDeviceList.contains(device)) {
//                        mbluetoothDeviceList.add(device);
//                        //BleDevice bleDevice = new BleDevice(device, scanRecord, rssi);
//                        //bleDeviceList.add(bleDevice);
//                       Log.e(TAG,"Find Ble Lock:" + devicename + "," + device.getBluetoothDevice().getAddress());
//
//                        if(!mAutoOpenDoor)
//                            return;
//                    }
//
//            }
//        }catch (Exception ee){
//            LogHelper.writeException("",ee);
//        }
//    }
//
//    //开锁
//    public void openLock(BluetoothDevice device){
//
//            boolean connectrsult=connect(device.getAddress(),false);
//           Log.e(TAG,"Start Connect Lock:"+device.getBluetoothDevice().getAddress()+",Result="+connectrsult);
//
//
//    }
//    /**
//     * 蓝牙链接
//     *
//     * @param address 执行链接的MAC地址
//     * @return 是否连接成功
//     */
//    private boolean connect(final String address,boolean isreconnect) {
//        battery=0;
//        if (mBluetoothAdapter == null || address == null) {
//            //Log.w(TAG, "BluetoothAdapter not initialized or unspecified address.");
//            return false;
//        }
//
//        if(isreconnect) {
//            startShowProgressDialog();
//        }
//        if (mBluetoothGatt != null) {
//            mBluetoothGatt.disconnect();
//            mBluetoothGatt.close();
//        }
//        mBluetoothAdapter.getBluetoothLeScanner().stopScan(myScanCallback);
//        try {
//            Thread.sleep(1000);
//        }catch (Exception e){}
//        final BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);
//        if (device == null) {
//           //Log.w(TAG, "Device not found.  Unable to connect.");
//            return false;
//        }
//        mBluetoothGatt = device.connectGatt(mactivity, false, mGattCallback);
//        //Log.d(TAG, "Trying to create a new connection.");
//        //mBluetoothDeviceAddress = address;
//        if(mBluetoothGatt==null)
//            return false;
//
//        return true;
//    }
//    //与蓝牙设备的连接通信状态
//    private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
//        /**
//         * 连接状态
//         */
//        @Override
//        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
//            try {
//                if (newState == BluetoothProfile.STATE_CONNECTED) {// 连接成功
//                    onBluetoothGattCallback(ACTION_GATT_CONNECTED);
//                    boolean result=mBluetoothGatt.discoverServices();
//                   Log.e(TAG,"Lock Start discoverServices.Result="+result);
//                }
//                else if (newState == BluetoothProfile.STATE_DISCONNECTED) {// 断开连接
//                   // gatt.close();
//                    onBluetoothGattCallback(ACTION_GATT_DISCONNECTED);
//                }
//            }catch (Exception ee){
//                LogHelper.writeException(ee);
//            }
//        }
//
//        /**
//         * 发现服务
//         */
//        @Override
//        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
//            try {
//               Log.e(TAG,"Lock onServicesDiscovered status= " + status);
//                if (status == BluetoothGatt.GATT_SUCCESS) {
//
//
//                        //获取服务的对象并判断是否为空
//                        BluetoothGattService service = gatt.getService(TMPL_SERVICE_UUID);
//                        if (null == service) {
//                           Log.e(TAG,"根据SERVICE_UUID获取服务为null");
//                            return;
//                        }
//                        //获取写入特征值和通知特征值的对象并判断是否为空
//                        BluetoothGattCharacteristic read_characteristic = service.getCharacteristic(TMPL_Read_UUID);
//                        //开启通知属性
//                        if (gatt.setCharacteristicNotification(read_characteristic, true)) {
//                            //List<BluetoothGattDescriptor> descriptorlist = read_characteristic.getDescriptors();
//                            BluetoothGattDescriptor descriptor = read_characteristic.getDescriptor( TMPL_CCCD);
//                            if (null != descriptor) {
//                                descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
//                                gatt.writeDescriptor(descriptor);
//                            }
//                        }
//                        write_characteristic = service.getCharacteristic(TMPL_Write_UUID);
//
//
//                    if (null == write_characteristic) {
//                       Log.e(TAG,"没有获取到蓝牙的读写属性。");
//                        return;
//                    }
//
//                    //发送广播通知前端
//                    onBluetoothGattCallback(ACTION_GATT_SERVICES_DISCOVERED);
//                }
//                else {
//                   Log.e(TAG,"OpenNokeBleLockHelper.onServicesDiscovered status= " + status);
//                }
//
//            }catch (Exception ee){
//                LogHelper.writeException(ee);
//            }
//        }
//
//        /**
//         * 通知的回调。。蓝牙设备发送过来数据
//         */
//        @Override
//        public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
//            onBluetoothGattCallback(ACTION_BLE_REAL_DATA, characteristic.getValue());
//        }
//        /**
//         * 通知的回调。。蓝牙设备发送过来数据
//         */
//        @Override
//        public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
//            onBluetoothGattCallback(ACTION_BLE_REAL_DATA, characteristic.getValue());
//        }
//    };
//    public void onBluetoothGattCallback(String action) {
//        onBluetoothGattCallback(action,null);
//    }
//    public void onBluetoothGattCallback(String action,byte[] values) {
//        try {
//            switch (action) {
//                case ACTION_GATT_CONNECTED:
//                    //链接
//                    mactivity.runOnUiThread(new Runnable() {
//                        @Override
//                        public void run() {
//                            if (progressDialog != null) {
//                                progressDialog.setMessage("连接锁成功...");
//                            }
//                        }
//                    });
//                   Log.e(TAG,"Lock Connect Success."+hashCode());
//                    break;
//                case ACTION_GATT_DISCONNECTED:
//                    //断开
//                    dismissprogressDialog();
//                   Log.e(TAG,"Lock DisConnected."+hashCode());
//                    if(mneedreconnect) {
//                        mneedreconnect = false;
//                        boolean connectrsult = connect(getCurrentOpeningdevice().getBluetoothDevice().getAddress(),true);
//                       Log.e(TAG,"ReConnect Lock:" + getCurrentOpeningdevice().getBluetoothDevice().getAddress() + ",Result=" + connectrsult);
//                    }
//
//                    break;
//                case ACTION_GATT_SERVICES_DISCOVERED:
//                    mneedreconnect=false;
//                   //Log.e(TAG,"Lock GATT_SERVICES_DISCOVERED."+hashCode());//add by 20221026
//                    //发现服务..mWorkModel:0=开锁，1=查询参数，2=设置参数
//                    if(mWorkModel==0) {
//                            if (mLockIsOpened || mIsDoCheckLockState)
//                                handler.sendEmptyMessageDelayed(4, 500);//验封.检测锁状态
//                            else
//                                handler.sendEmptyMessageDelayed(0, 500);//解封，开锁
//                        }
//
//
//                    break;
//                case ACTION_BLE_REAL_DATA:
//                        //解析锁返回的数据
//                        TMPL_processData(values);
//
//                    break;
//                case BluetoothAdapter.ACTION_STATE_CHANGED:
//                    // Log.e(LockManageActivity.class.getSimpleName(),"state_changed");
//                    break;
//            }
//        }catch (Exception ee){
//            LogHelper.writeException(ee);
//        }
//    }
//
//
//    private Handler handler = new Handler() {
//        @Override
//        public void handleMessage(Message msg) {
//            myhandleMessage(msg);
//        }
//    };
//    private void myhandleMessage(Message msg) {
//        try {
//            startCaptureTimeCount();
//            switch (msg.what) {
//                case 0://发送开锁指令
//                    mIsDoCheckLockState=false;
//
//                    TMPL_ReadLockUTCTime();
//
//                    break;
//                case 1://获取电量
//                    byte[] batteryBytes = {0x02, 0x01, 0x01, 0x01, token[0], token[1], token[2], token[3], 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
//                    boolean result=writeCharacteristic_GuaSuo(batteryBytes);
//                   Log.e(TAG,"Lock 发送获取电量指令="+result);
//                    break;
//                case 2://开锁
//                    byte[] sendDataBytes = new byte[]{0x05, 0x01, 0x06, password[0], password[1], password[2], password[3], password[4], password[5], token[0], token[1], token[2], token[3], 0x00, 0x00, 0x00};
//                    result= writeCharacteristic_GuaSuo(sendDataBytes);
//                   Log.e(TAG,"Lock 发送开锁指令="+result);
//                    break;
//                case 3://获取锁状态
//                    byte[] sendDataBytes1 = new byte[]{0x05, 0x0E, 0x01, 0X01, token[0], token[1], token[2], token[3], 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
//                    result=writeCharacteristic_GuaSuo(sendDataBytes1);
//                   Log.e(TAG,"Lock 发送获取锁状态指令="+result);
//                    break;
//                case 4://发送施封指令。。航鸿达
//                       TMPL_SendGetLockStateCMD();
//                      Log.e(TAG,"Lock 发送获取锁状态指令,result="+result);
//                    break;
//            }
//        }catch (Exception ee){
//            //ee.printStackTrace();
//            LogHelper.writeException("",ee);
//            showMessage(ee.getMessage());
//        }
//    }
//
//
//    public static final UUID TMPL_SERVICE_UUID = UUID.fromString("6e400001-b5a3-f393-e0a9-e50e24dcca9e");
//    public static final UUID TMPL_Write_UUID =   UUID.fromString("6e400002-b5a3-f393-e0a9-e50e24dcca9e");
//    public static final UUID TMPL_Read_UUID =    UUID.fromString("6e400003-b5a3-f393-e0a9-e50e24dcca9e");
//    public static final UUID TMPL_CCCD =         UUID.fromString("00002902-0000-1000-8000-00805f9b34fb");
//    private static  BleLockParamInfo tmpl_bleLockParamInfo ;
//    //先获取锁的时间
//    private void TMPL_ReadLockUTCTime(){
//        byte[] cmdbytes=new byte[]{0x7D,0x7D,0x10,TMPL_Key,0x50,(byte)0xFF,(byte)0xFF,(byte)0xFF,(byte)0xFF,0x5F,0x00,0x00,0x00,0x20,0x00,0x2F};
//        writeCharacteristic_TMPL(cmdbytes);
//       Log.e(TAG,"Lock 发送TMPL UTC指令.");
//    }
//    //发送开锁指令
//    private void TMPL_SendOpenLockCMD(int utctime){
//        byte[] utcdata=ByteConvert.ConvertIntToBytes_BIG_ENDIAN(utctime);
//        byte[] cmdbytes=new byte[]{0x7D,0x7D,0x10,TMPL_Key,0x50,(byte)0xFF,(byte)0xFF,(byte)0xFF,(byte)0xFF,utcdata[0],utcdata[1],utcdata[2],utcdata[3],0x30,0x00,0x2F};
//        writeCharacteristic_TMPL(cmdbytes);
//       Log.e(TAG,"Lock 发送TMPL开锁指令.");
//    }
//    //获取锁的状态
//    private void TMPL_SendGetLockStateCMD(){
//        byte[] cmdbytes=new byte[]{0x7D,0x7D,0x0F,TMPL_Key,0x50,(byte)0xFF,(byte)0xFF,(byte)0xFF,(byte)0xFF,0x5F,0x00,0x00,0x00,0x10,0x10};//读取固件版本号等参数
//       // byte[] cmdbytes=new byte[]{0x7D,0x7D,0x0F,0x00,0x50,(byte)0xFF,(byte)0xFF,(byte)0xFF,(byte)0xFF,0x5F,0x00,0x00,0x00,0x13,0x13};
//        boolean result=writeCharacteristic_TMPL(cmdbytes);
//       Log.e(TAG,"TMPL发送查询锁状态指令。="+result);
//    }
//    private void TMPL_ReadLockParam_IP(){
//        //byte[] cmdbytes=new byte[]{0x7D,0x7D,0x0F,TMPL_Key,0x50,(byte)0xFF,(byte)0xFF,(byte)0xFF,(byte)0xFF,0x5F,0x00,0x00,0x00,0x23,0x23};//IP命令
//        byte[] cmdbytes=new byte[]{0x7D,0x7D,0x10,TMPL_Key,0x50,(byte)0xFF,(byte)0xFF,(byte)0xFF,(byte)0xFF,0x5F,0x00,0x00,0x00,0x26,0x01,0x26};
//        //LogHelper.write("TMPL_ReadLockParam_IP:"+CDRYTLock_Utils.bytes2String(cmdbytes));
//        writeCharacteristic_TMPL(cmdbytes);
//    }
//
//    private void TMPL_WriteLockParam_IP()throws Exception{
//        if(mbleLockParamInfo==null)return;
//        String[] ipsplit=mbleLockParamInfo.ServerIP_Value.split("\\.");
//        byte[] ipdata;
//        byte ipflag=0x00;
//        if(ipsplit.length==4) {//是ip地址
//            ipflag=0x00;
//            ipdata = new byte[4];
//            for (int i = 0; i < ipdata.length; i++) {
//                ipdata[i] = (byte) Integer.parseInt(ipsplit[i]);
//            }
//        }
//        else{//是域名
//            ipflag=0x01;
//            ipdata=mbleLockParamInfo.ServerIP_Value.getBytes();
//        }
//        byte[] portdata=ByteConvert.ConvertIntToBytes_BIG_ENDIAN(Integer.parseInt(mbleLockParamInfo.ServerPort_Value));
//        //byte[] cmdbytes=new byte[]{0x7D,0x7D,0x15,TMPL_Key,0x50,(byte)0xFF,(byte)0xFF,(byte)0xFF,(byte)0xFF,0x5F,0x00,0x00,0x00,0x23,ipdata[0],ipdata[1],ipdata[2],ipdata[3],portdata[2],portdata[3],0x23};
//        //byte[] cmdbytes=new byte[]{0x7D,0x7D,0x15,TMPL_Key,0x50,(byte)0xFF,(byte)0xFF,(byte)0xFF,(byte)0xFF,0x5F,0x00,0x00,0x00,0x26,ipdata[0],ipdata[1],ipdata[2],ipdata[3],portdata[2],portdata[3],0x23};
//        ByteBuffer bf=ByteBuffer.allocate(18+ipdata.length);
//        bf.put(new byte[]{0x7D,0x7D});
//        bf.put((byte)(18+ipdata.length));
//        bf.put(TMPL_Key);
//        bf.put(new byte[]{0x50,(byte)0xFF,(byte)0xFF,(byte)0xFF,(byte)0xFF,0x5F,0x00,0x00,0x00,0x26});
//        bf.put(ipflag);
//        bf.put(ipdata);
//        bf.put(new byte[]{portdata[2],portdata[3]});
//        bf.put((byte) 0x23);
//        byte[] cmdbytes=bf.array();
//       //Log.e(TAG,"TMPL_WriteLockParam_IP:"+CDRYTLock_Utils.bytes2String(cmdbytes));
//        writeCharacteristic_TMPL(cmdbytes);
//    }
//    private void TMPL_ReadLockParam_APN(){
//        byte[] cmdbytes=new byte[]{0x7D,0x7D,0x0F,TMPL_Key,0x50,(byte)0xFF,(byte)0xFF,(byte)0xFF,(byte)0xFF,0x5F,0x00,0x00,0x00,0x25,0x23};
//        //LogHelper.write("TMPL_ReadLockParam_APN:"+CDRYTLock_Utils.bytes2String(cmdbytes));
//        writeCharacteristic_TMPL(cmdbytes);
//    }
//    private void TMPL_WriteLockParam_APN(){
//        if(mbleLockParamInfo==null)return;
//       // byte[] cmdbytes=new byte[]{0x7D,0x7D,0x0F,TMPL_Key,0x50,(byte)0xFF,(byte)0xFF,(byte)0xFF,(byte)0xFF,0x5F,0x00,0x00,0x00,0x25,0x23};
//        byte[] apnnamedata=mbleLockParamInfo.APN1Name_Value.getBytes();
//        ByteBuffer bf=ByteBuffer.allocate(15+apnnamedata.length);
//        bf.put(new byte[]{0x7D,0x7D});
//        bf.put((byte)(15+apnnamedata.length));
//        bf.put(TMPL_Key);
//        bf.put(new byte[]{0x50,(byte)0xFF,(byte)0xFF,(byte)0xFF,(byte)0xFF,0x5F,0x00,0x00,0x00,0x25});
//        bf.put(apnnamedata);
//        bf.put((byte) 0x23);
//        byte[] cmdbytes=bf.array();
//        //LogHelper.write("TMPL_ReadLockParam_APN:"+CDRYTLock_Utils.bytes2String(cmdbytes));
//        writeCharacteristic_TMPL(cmdbytes);
//    }
//    /**
//     * 处理接收的数据
//     *
//     * @param data
//     */
//    public void TMPL_processData(byte[] data)throws Exception {
//        String getData = CDRYTLock_Utils.bytes2String(data);
//       Log.e(TAG,"TMPL解析数据:" + getData);
//        if(data.length<3||data[0]!=0x7D||data[1]!=0x7D){
//            return;
//        }
//        stopCaptureTimeCount();
//        if(data.length>=16&&data[4]==0x50&&data[13]==0x20){//读取UTC时间
//            int utctime=byte2Int(new byte[]{data[9],data[10],data[11],data[12]});
////            Calendar nowtime=Calendar.getInstance();
////            nowtime.clear();
////            nowtime.set(1970,1,1,0,0,0);
////            nowtime.add(Calendar.SECOND,utctime);
////           Log.e(TAG,"TMPL锁UTC:"+utctime+","+Util.formatDateTime( nowtime.getTime()));
//            TMPL_SendOpenLockCMD(utctime+30);
//            //TMPL_SendUpGradeCMD();
//        }
//        else if(data.length==16&&data[4]==0x50&&data[13]==0x30){//开锁回复
////            int utctime=byte2Int(new byte[]{data[9],data[10],data[11],data[12]});
////            Calendar nowtime=Calendar.getInstance();
////            nowtime.clear();
////            nowtime.set(1970,1,1,0,0,0);
////            nowtime.add(Calendar.SECOND,utctime);
////           Log.e(TAG,"TMPL开锁UTC:"+utctime+","+Util.formatDateTime( nowtime.getTime()));
//            dismissprogressDialog();
//            if(data[14]==0x00){//锁状态是开
//                mLockIsOpened = true;
//                mLockOpenedtime=System.currentTimeMillis();
//                mactivity.runOnUiThread(new Runnable() {
//                    @Override
//                    public void run() {
//                        if (mOnBleLockStateChangedListener != null)
//                            mOnBleLockStateChangedListener.onOpenLockSuccess(battery, true);
//                    }
//                });
//                TMPL_startCheckLockSeal();
//            }
//            else{
//                mactivity.runOnUiThread(new Runnable() {
//                    @Override
//                    public void run() {
//                        Util.showFailDialog(mactivity, "开锁失败！", true);
//                    }
//                });
//            }
//        }
//        else if(data.length>22&&data[4]==0x50&&data[13]==0x10) {//查询锁状态回复
//            //7d 7d 2f 00 50 f1 03 00 21 64 f1 f7 46 10 20 23 08 16 00 12 01 aa 11 20 1c 14 3839383630344439323632334430333336363435 03
////            int utctime=byte2Int(new byte[]{data[9],data[10],data[11],data[12]});
////            Calendar nowtime=Calendar.getInstance();
////            nowtime.clear();
////            //nowtime.set(1970,1,1,0,0,0);
////            nowtime.add(Calendar.SECOND,utctime);
////            Date date=new Date(utctime*1000);
//
//            //LogHelper.write("TMPL开锁UTC:"+utctime+","+Util.formatDateTime( nowtime.getTime()));
//            int powerv=byte2Int(new byte[]{0,0,data[20],data[21]});
//            battery= (int) GetPowerPercent_HHD(powerv/100.0d);
//            if(mOnBleLockStateChangedListener!=null)
//                mOnBleLockStateChangedListener.onGetLockBattery(battery);
//            int state0= data[22]&0x01;//锁梁开关：0=锁杆已拉开，1=锁杆未拉开或已按下，电机不一定锁上
//            int state1= data[22]&0x02;//滚珠开关，用于判断锁体放置方向：0 = 锁体正向放置，1 = 锁体反向放置
//            int state2= data[22]&0x04;//霍尔开关：0=锁杆已吸住。4=锁杆未吸住，
//            int state3= data[22]&0x08;//电机开关：0=槽型光电开关未被遮挡（未上锁），8= 槽型光电开关被遮挡（已上锁）
//            int state4= data[22]&0x10;//防拆开关，用于防拆。0 = 防拆开关正常，1 = 锁面盖已被拆开
//            String simiccid="";
//            int simlength=0;
//            if(data.length>46){
//                simlength=byte2Int(new byte[]{0,0,0,data[25]});
//                simiccid=new String(data,26,simlength,"ASCII");
//                if(tmpl_bleLockParamInfo!=null&&mOnBleLockStateChangedListener != null)
//                    tmpl_bleLockParamInfo.SIMICCID_Value=simiccid;
//                    mOnBleLockStateChangedListener.onGetLockParam(tmpl_bleLockParamInfo);
//            }
//           Log.e(TAG,"TMPL锁状态：锁梁开关="+state0+",倾斜开关="+state1+",霍尔开关="+state2+",电机开关="+state3+",防拆开关="+state4+
//                    (data.length>24?(",4G开关="+ByteConvert.byteToInt(data[23])+",4G信号强度="+ByteConvert.byteToInt(data[24])):"")+",电压="+powerv+",SIM="+simiccid);
//            if(!mLockIsOpened)return;
//            ////读锁状态
//            if(getCurrentOpeningdevice().getDeviceName().startsWith("TMOL")){//TMOL是嵌入式带把手门锁，TMPL是挂锁
//                if (state0 == 0&&state3==8) {//state3表示霍尔开关。。state0表示锁舌
//                    //showcdtestMessage("得到状态:关");
//                    mLockIsOpened = false;
//                    mactivity.runOnUiThread(new Runnable() {
//                        @Override
//                        public void run() {
//                            if (mOnBleLockStateChangedListener != null)
//                                mOnBleLockStateChangedListener.onCloseLockSuccess();
//                        }
//                    });
//                    TMPL_stopCheckLockSeel();
//                    disconnect();
//                }
//                else //if (state3 == 0)
//                {
//                    // showcdtestMessage("得到状态:开");
//                    if (mIsDoCheckLockState) {
//                        showMessage("锁没有关闭！");
//                    }
//                }
//            }
//            else {
//                if (state0==1&&state3 == 8) {
//                    //showcdtestMessage("得到状态:关");
//                    mLockIsOpened = false;
//                    mactivity.runOnUiThread(new Runnable() {
//                        @Override
//                        public void run() {
//                            if (mOnBleLockStateChangedListener != null)
//                                mOnBleLockStateChangedListener.onCloseLockSuccess();
//                        }
//                    });
//                    TMPL_stopCheckLockSeel();
//                    disconnect();
//                }
//                else //if (state0==0&&state3 == 0)
//                {
//                    // showcdtestMessage("得到状态:开");
//                    if (mIsDoCheckLockState) {
//                        showMessage("锁没有关闭！");
//                    }
//                }
//            }
//            mIsDoCheckLockState=false;
//            dismissprogressDialog();
//        }
//        else if(data.length>19&&data[4]==0x50&&data[13]==0x23){//读取设置Ip参数回应
//            String ip=ByteConvert.byteToInt(data[14])+"."+ByteConvert.byteToInt(data[15])+"."+ByteConvert.byteToInt(data[16])+"."+ByteConvert.byteToInt(data[17]);
//            int port=byte2Int(new byte[]{0,0,data[18],data[19]});
//           //Log.e(TAG,"TMPL锁Param:IP="+ip+",Port="+port);
//            tmpl_bleLockParamInfo = new BleLockParamInfo();
//            tmpl_bleLockParamInfo.ServerIP_Value=ip;
//            tmpl_bleLockParamInfo.ServerPort_Value=String.valueOf(port);
//            TMPL_ReadLockParam_APN();
//        }
//        else if(data.length>15&&data[4]==0x50&&data[13]==0x25) {//读取、设置APN
//            String apnname=new String(data,14,data.length-15,"UTF-8");
//           //Log.e(TAG,"TMPL锁Param:apnname="+apnname);
//            if(tmpl_bleLockParamInfo!=null)
//                tmpl_bleLockParamInfo.APN1Name_Value=apnname;
//            if (mOnBleLockStateChangedListener != null)
//                mOnBleLockStateChangedListener.onGetLockParam(tmpl_bleLockParamInfo);
//            dismissprogressDialog();
//            if (mWorkModel==2&&mOnBleLockStateChangedListener != null)
//                mOnBleLockStateChangedListener.onSetLockParamResult(true);
//            else if (mWorkModel==1)//查参数
//            {
//                TMPL_SendGetLockStateCMD();
//            }
//        }
//        else if(data.length>19&&data[4]==0x50&&data[13]==0x26){//读取设置服务器地址和端口参数回应
//            byte ipflag=data[14];
//            String ip="";
//            if(ipflag==0x00)
//                ip=ByteConvert.byteToInt(data[15])+"."+ByteConvert.byteToInt(data[16])+"."+ByteConvert.byteToInt(data[17])+"."+ByteConvert.byteToInt(data[18]);
//            else
//                ip=new String(data,19,data.length-22);
//            int port=byte2Int(new byte[]{0,0,data[data.length-3],data[data.length-2]});
//            //Log.e(TAG,"TMPL锁Param:IP="+ip+",Port="+port);
//            tmpl_bleLockParamInfo = new BleLockParamInfo();
//            tmpl_bleLockParamInfo.ServerIP_Value=ip;
//            tmpl_bleLockParamInfo.ServerPort_Value=String.valueOf(port);
//            if (mWorkModel==2)//写参数
//            {
//                TMPL_WriteLockParam_APN();
//            }
//            else {
//                TMPL_ReadLockParam_APN();
//            }
//        }
//    }
//    //开锁成功后，不停向锁发送验封指令，判断是否施封
//    private void TMPL_startCheckLockSeal(){
//        //if(1==1)return;
//        if(!mLockIsOpened)
//            return;
//        handler.postDelayed(new Runnable() {
//            @Override
//            public void run() {
//                TMPL_SendGetLockStateCMD();
//            }
//        },1000);
//        handler.removeCallbacks(mCheckTMPLLockSealRunnable);
//        handler.postDelayed(mCheckTMPLLockSealRunnable,3000);
//    }
//    private void TMPL_stopCheckLockSeel(){
//        handler.removeCallbacks(mCheckTMPLLockSealRunnable);
//    }
//    Runnable mCheckTMPLLockSealRunnable = new Runnable() {
//        @Override
//        public void run() {
//            try {
//                if(!mLockIsOpened||mCurrentOpeningLock==null||mBluetoothGatt==null)return;
//                if(mBluetoothManager.getConnectionState(getCurrentOpeningdevice().getBluetoothDevice(), BluetoothGatt.GATT) == BluetoothProfile.STATE_CONNECTED)
//                    TMPL_SendGetLockStateCMD();
////                else if(mBluetoothManager.getConnectionState(mCurrentOpeningdevice, BluetoothGatt.GATT) == BluetoothProfile.STATE_DISCONNECTED){
////                  // boolean conresult= mBluetoothGatt.connect();
//////                   if(conresult) {
//////                       TMPL_SendGetLockStateCMD();
//////                   }
////                    mBluetoothGatt = mCurrentOpeningdevice.connectGatt(mactivity, false, mGattCallback);
////                  Log.e(TAG,"重新连接锁。");
////                }
//                handler.postDelayed(mCheckTMPLLockSealRunnable, 3000);
//                //Log.e(TAG,"Send CheckLockSeal CMD.");
//                //showMessage("检测锁状态。");
//            }catch (Exception ee){
//                LogHelper.writeException(ee);
//            }
//        }
//    };
//    //通过蓝牙向锁发送数据
//    public boolean writeCharacteristic_TMPL(byte[] bytes) {
//        if (mBluetoothGatt == null || write_characteristic == null) {
//            return false;
//        }
//        if (bytes != null) {
//            //LogHelper.write("加密前："+CDRYTLock_Utils.bytes2String(bytes));
//            Encrypt_TMPL(bytes);
//           //Log.e(TAG,"加密后："+CDRYTLock_Utils.bytes2String(bytes));
//            write_characteristic.setValue(bytes);
//            //Log.e(BluetoothLeService.class.getSimpleName(),"bytes:"+HexUtils.bytesToHexString(bytes));
//            return mBluetoothGatt.writeCharacteristic(write_characteristic);
//        }
//        return false;
//    }
//    private static final byte[] TMPL_EncryptKey=new byte[]{0x1D,0x22,0x45,0x28};
//    private static final byte TMPL_Key=0x3E;
//    //加密
//    private void Encrypt_TMPL(byte[] cmdalldata){
//        byte[] encryptkeytem=new byte[4];
//        encryptkeytem[0]=(byte) (TMPL_EncryptKey[0]^TMPL_Key);
//        encryptkeytem[1]=(byte) (TMPL_EncryptKey[1]^TMPL_Key);
//        encryptkeytem[2]=(byte) (TMPL_EncryptKey[2]^TMPL_Key);
//        encryptkeytem[3]=(byte) (TMPL_EncryptKey[3]^TMPL_Key);
//
//        TMPL_XOR(cmdalldata);
//
//        for (int i = 4; i < cmdalldata.length-1; i++) {
//            cmdalldata[i]=(byte)(cmdalldata[i]^encryptkeytem[i%4]);
//        }
//
//    }
//    //异或校验，最后一位是校验位
//    private void TMPL_XOR(byte[] data){
//        byte checkbyte=0;
//        for (int i = 0; i < data.length-1; i++) {
//            checkbyte=(byte) (data[i]^checkbyte);
//        }
//        data[data.length-1]=checkbyte;
//    }
//
//
//}